home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / cg.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  42KB  |  1,188 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Memory
  8. #include "Memory.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_IO
  12. #include "IO.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Idents
  20. #include "Idents.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Errors
  28. #include "Errors.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Scanner
  32. #include "Scanner.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Parser
  36. #include "Parser.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Tree2
  44. #include "Tree2.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Semantics
  48. #include "Semantics.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Order
  52. #include "Order.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Dialog
  56. #include "Dialog.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_GramMod
  60. #include "GramMod.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_TreeMod1
  64. #include "TreeMod1.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_EvalMod
  68. #include "EvalMod.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_EvalMod2
  72. #include "EvalMod2.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_EvalMod3
  76. #include "EvalMod3.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_GramC
  80. #include "GramC.h"
  81. #endif
  82.  
  83. #ifndef DEFINITION_GramYacc
  84. #include "GramYacc.h"
  85. #endif
  86.  
  87. #ifndef DEFINITION_TreeC1
  88. #include "TreeC1.h"
  89. #endif
  90.  
  91. #ifndef DEFINITION_EvalC
  92. #include "EvalC.h"
  93. #endif
  94.  
  95. #ifndef DEFINITION_EvalC2
  96. #include "EvalC2.h"
  97. #endif
  98.  
  99. #ifndef DEFINITION_EvalC3
  100. #include "EvalC3.h"
  101. #endif
  102.  
  103. static CHAR DefExtMc [] = ".md";
  104. static CHAR ImpExtMc [] = ".mi";
  105. static CHAR LisExtMc [] = ".imp";
  106. static CHAR DefExtC [] = ".h";
  107. static CHAR ImpExtC [] = ".c";
  108. static Strings_tString CgLib, DefFile, TreeFile, EvalFile, String, PathS;
  109. static struct S_1 {
  110.     CHAR A[255 + 1];
  111. } Argument, PathA;
  112. static SHORTCARD j;
  113. static CHAR ch;
  114. static Sets_tSet AllOptions;
  115. static BOOLEAN HasArgs;
  116. static void GenerateMacros ARGS(());
  117. static void ReadTraceTab ARGS(());
  118. static void SetTrace ARGS((Tree_tTree t));
  119. static IO_tFile SmartOpen ARGS((Strings_tString FileName));
  120. static void SmartClose ARGS((Strings_tString FileName, IO_tFile f));
  121.  
  122.  
  123. static void GenerateMacros
  124. # ifdef __STDC__
  125. ()
  126. # else
  127. ()
  128. # endif
  129. {
  130.   IO_tFile TypeTabFile;
  131.   Strings_tString s;
  132.   Idents_tIdent i;
  133.   INTEGER j;
  134.  
  135.   if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  136.     Strings_ArrayToString((STRING)"TypeTab.c", 9L, &String);
  137.   } else {
  138.     Strings_ArrayToString((STRING)"TypeTab.m", 9L, &String);
  139.   }
  140.   Strings_Assign(&PathS, &CgLib);
  141.   Strings_Concatenate(&PathS, &String);
  142.   Strings_Append(&PathS, '\0');
  143.   Strings_StringToArray(&PathS, PathA.A, 256L);
  144.   TypeTabFile = IO_ReadOpen(PathA.A, 256L);
  145.   Strings_ArrayToString((STRING)"yy", 2L, &PathS);
  146.   Idents_GetString(Tree_iModule, &Tree_ModuleName);
  147.   Strings_Concatenate(&PathS, &Tree_ModuleName);
  148.   Strings_ArrayToString((STRING)".w", 2L, &String);
  149.   Strings_Concatenate(&PathS, &String);
  150.   Strings_Append(&PathS, '\0');
  151.   Strings_StringToArray(&PathS, PathA.A, 256L);
  152.   Tree_f = IO_WriteOpen(PathA.A, 256L);
  153.   while (!IO_EndOfFile(TypeTabFile)) {
  154.     Strings_ReadL(TypeTabFile, &s);
  155.     i = Idents_MakeIdent(&s);
  156.     if (i <= Semantics_TypeCount && Sets_IsElement((LONGCARD)i, &Tree_TypeNames)) {
  157.       Sets_Exclude(&Tree_TypeNames, (LONGCARD)i);
  158.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  159.       Tree_WI(i);
  160.       IO_WriteNl(Tree_f);
  161.       Strings_ReadL(TypeTabFile, &s);
  162.       Strings_WriteL(Tree_f, &s);
  163.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  164.       IO_WriteNl(Tree_f);
  165.       IO_WriteS(Tree_f, (STRING)"# ifndef close", 14L);
  166.       Tree_WI(i);
  167.       IO_WriteNl(Tree_f);
  168.       Strings_ReadL(TypeTabFile, &s);
  169.       Strings_WriteL(Tree_f, &s);
  170.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  171.       IO_WriteNl(Tree_f);
  172.       IO_WriteS(Tree_f, (STRING)"# ifndef read", 13L);
  173.       Tree_WI(i);
  174.       IO_WriteNl(Tree_f);
  175.       Strings_ReadL(TypeTabFile, &s);
  176.       Strings_WriteL(Tree_f, &s);
  177.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  178.       IO_WriteNl(Tree_f);
  179.       IO_WriteS(Tree_f, (STRING)"# ifndef write", 14L);
  180.       Tree_WI(i);
  181.       IO_WriteNl(Tree_f);
  182.       Strings_ReadL(TypeTabFile, &s);
  183.       Strings_WriteL(Tree_f, &s);
  184.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  185.       IO_WriteNl(Tree_f);
  186.       IO_WriteS(Tree_f, (STRING)"# ifndef get", 12L);
  187.       Tree_WI(i);
  188.       IO_WriteNl(Tree_f);
  189.       Strings_ReadL(TypeTabFile, &s);
  190.       Strings_WriteL(Tree_f, &s);
  191.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  192.       IO_WriteNl(Tree_f);
  193.       IO_WriteS(Tree_f, (STRING)"# ifndef put", 12L);
  194.       Tree_WI(i);
  195.       IO_WriteNl(Tree_f);
  196.       Strings_ReadL(TypeTabFile, &s);
  197.       Strings_WriteL(Tree_f, &s);
  198.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  199.       IO_WriteNl(Tree_f);
  200.       IO_WriteS(Tree_f, (STRING)"# ifndef copy", 13L);
  201.       Tree_WI(i);
  202.       IO_WriteNl(Tree_f);
  203.       Strings_ReadL(TypeTabFile, &s);
  204.       Strings_WriteL(Tree_f, &s);
  205.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  206.       IO_WriteNl(Tree_f);
  207.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  208.       Tree_WI(i);
  209.       IO_WriteNl(Tree_f);
  210.       Strings_ReadL(TypeTabFile, &s);
  211.       Strings_WriteL(Tree_f, &s);
  212.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  213.       IO_WriteNl(Tree_f);
  214.     } else {
  215.       for (j = 1; j <= 8; j += 1) {
  216.         IO_ReadNl(TypeTabFile);
  217.       }
  218.     }
  219.   }
  220.   IO_ReadClose(TypeTabFile);
  221.   if (Tree_itTree <= Semantics_TypeCount) {
  222.     Sets_Exclude(&Tree_TypeNames, (LONGCARD)Tree_itTree);
  223.   }
  224.   while (!Sets_IsEmpty(Tree_TypeNames)) {
  225.     i = Sets_Extract(&Tree_TypeNames);
  226.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  227.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  228.       Tree_WI(i);
  229.       IO_WriteNl(Tree_f);
  230.       IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  231.       Tree_WI(i);
  232.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  233.       IO_WriteNl(Tree_f);
  234.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  235.       IO_WriteNl(Tree_f);
  236.       IO_WriteS(Tree_f, (STRING)"# ifndef close", 14L);
  237.       Tree_WI(i);
  238.       IO_WriteNl(Tree_f);
  239.       IO_WriteS(Tree_f, (STRING)"# define close", 14L);
  240.       Tree_WI(i);
  241.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  242.       IO_WriteNl(Tree_f);
  243.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  244.       IO_WriteNl(Tree_f);
  245.       IO_WriteS(Tree_f, (STRING)"# ifndef read", 13L);
  246.       Tree_WI(i);
  247.       IO_WriteNl(Tree_f);
  248.       IO_WriteS(Tree_f, (STRING)"# define read", 13L);
  249.       Tree_WI(i);
  250.       IO_WriteS(Tree_f, (STRING)"(a)    yyReadHex ((unsigned char *) & a, sizeof (a));", 50L);
  251.       IO_WriteNl(Tree_f);
  252.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  253.       IO_WriteNl(Tree_f);
  254.       IO_WriteS(Tree_f, (STRING)"# ifndef write", 14L);
  255.       Tree_WI(i);
  256.       IO_WriteNl(Tree_f);
  257.       IO_WriteS(Tree_f, (STRING)"# define write", 14L);
  258.       Tree_WI(i);
  259.       IO_WriteS(Tree_f, (STRING)"(a)    yyWriteHex ((unsigned char *) & a, sizeof (a));", 51L);
  260.       IO_WriteNl(Tree_f);
  261.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  262.       IO_WriteNl(Tree_f);
  263.       IO_WriteS(Tree_f, (STRING)"# ifndef get", 12L);
  264.       Tree_WI(i);
  265.       IO_WriteNl(Tree_f);
  266.       IO_WriteS(Tree_f, (STRING)"# define get", 12L);
  267.       Tree_WI(i);
  268.       IO_WriteS(Tree_f, (STRING)"(a)    yyGet ((char *) & a, sizeof (a));", 37L);
  269.       IO_WriteNl(Tree_f);
  270.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  271.       IO_WriteNl(Tree_f);
  272.       IO_WriteS(Tree_f, (STRING)"# ifndef put", 12L);
  273.       Tree_WI(i);
  274.       IO_WriteNl(Tree_f);
  275.       IO_WriteS(Tree_f, (STRING)"# define put", 12L);
  276.       Tree_WI(i);
  277.       IO_WriteS(Tree_f, (STRING)"(a)    yyPut ((char *) & a, sizeof (a));", 37L);
  278.       IO_WriteNl(Tree_f);
  279.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  280.       IO_WriteNl(Tree_f);
  281.       IO_WriteS(Tree_f, (STRING)"# ifndef copy", 13L);
  282.       Tree_WI(i);
  283.       IO_WriteNl(Tree_f);
  284.       IO_WriteS(Tree_f, (STRING)"# define copy", 13L);
  285.       Tree_WI(i);
  286.       IO_WriteS(Tree_f, (STRING)"(a, b)", 6L);
  287.       IO_WriteNl(Tree_f);
  288.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  289.       IO_WriteNl(Tree_f);
  290.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  291.       Tree_WI(i);
  292.       IO_WriteNl(Tree_f);
  293.       IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  294.       Tree_WI(i);
  295.       IO_WriteS(Tree_f, (STRING)"(a, b)    memcmp ((char *) & a, (char *) & b, sizeof (a)) == 0", 59L);
  296.       IO_WriteNl(Tree_f);
  297.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  298.       IO_WriteNl(Tree_f);
  299.     } else {
  300.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  301.       Tree_WI(i);
  302.       IO_WriteNl(Tree_f);
  303.       IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  304.       Tree_WI(i);
  305.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  306.       IO_WriteNl(Tree_f);
  307.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  308.       IO_WriteNl(Tree_f);
  309.       IO_WriteS(Tree_f, (STRING)"# ifndef close", 14L);
  310.       Tree_WI(i);
  311.       IO_WriteNl(Tree_f);
  312.       IO_WriteS(Tree_f, (STRING)"# define close", 14L);
  313.       Tree_WI(i);
  314.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  315.       IO_WriteNl(Tree_f);
  316.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  317.       IO_WriteNl(Tree_f);
  318.       IO_WriteS(Tree_f, (STRING)"# ifndef read", 13L);
  319.       Tree_WI(i);
  320.       IO_WriteNl(Tree_f);
  321.       IO_WriteS(Tree_f, (STRING)"# define read", 13L);
  322.       Tree_WI(i);
  323.       IO_WriteS(Tree_f, (STRING)"(a)    yyReadHex (a);", 18L);
  324.       IO_WriteNl(Tree_f);
  325.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  326.       IO_WriteNl(Tree_f);
  327.       IO_WriteS(Tree_f, (STRING)"# ifndef write", 14L);
  328.       Tree_WI(i);
  329.       IO_WriteNl(Tree_f);
  330.       IO_WriteS(Tree_f, (STRING)"# define write", 14L);
  331.       Tree_WI(i);
  332.       IO_WriteS(Tree_f, (STRING)"(a)    yyWriteHex (a);", 19L);
  333.       IO_WriteNl(Tree_f);
  334.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  335.       IO_WriteNl(Tree_f);
  336.       IO_WriteS(Tree_f, (STRING)"# ifndef get", 12L);
  337.       Tree_WI(i);
  338.       IO_WriteNl(Tree_f);
  339.       IO_WriteS(Tree_f, (STRING)"# define get", 12L);
  340.       Tree_WI(i);
  341.       IO_WriteS(Tree_f, (STRING)"(a)    yyGet (a);", 14L);
  342.       IO_WriteNl(Tree_f);
  343.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  344.       IO_WriteNl(Tree_f);
  345.       IO_WriteS(Tree_f, (STRING)"# ifndef put", 12L);
  346.       Tree_WI(i);
  347.       IO_WriteNl(Tree_f);
  348.       IO_WriteS(Tree_f, (STRING)"# define put", 12L);
  349.       Tree_WI(i);
  350.       IO_WriteS(Tree_f, (STRING)"(a)    yyPut (a);", 14L);
  351.       IO_WriteNl(Tree_f);
  352.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  353.       IO_WriteNl(Tree_f);
  354.       IO_WriteS(Tree_f, (STRING)"# ifndef copy", 13L);
  355.       Tree_WI(i);
  356.       IO_WriteNl(Tree_f);
  357.       IO_WriteS(Tree_f, (STRING)"# define copy", 13L);
  358.       Tree_WI(i);
  359.       IO_WriteS(Tree_f, (STRING)"(a, b)", 6L);
  360.       IO_WriteNl(Tree_f);
  361.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  362.       IO_WriteNl(Tree_f);
  363.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  364.       Tree_WI(i);
  365.       IO_WriteNl(Tree_f);
  366.       IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  367.       Tree_WI(i);
  368.       IO_WriteS(Tree_f, (STRING)"(a, b)    yyIsEqual (a, b)", 23L);
  369.       IO_WriteNl(Tree_f);
  370.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  371.       IO_WriteNl(Tree_f);
  372.     }
  373.   }
  374.   if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  375.     IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  376.     Tree_WI(Tree_itTree);
  377.     IO_WriteNl(Tree_f);
  378.     IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  379.     Tree_WI(Tree_itTree);
  380.     IO_WriteS(Tree_f, (STRING)"(a)    a = ", 8L);
  381.     Tree_WI(Tree_iNoTree);
  382.     IO_WriteS(Tree_f, (STRING)";", 1L);
  383.     IO_WriteNl(Tree_f);
  384.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  385.     IO_WriteNl(Tree_f);
  386.     IO_WriteS(Tree_f, (STRING)"# ifndef close", 14L);
  387.     Tree_WI(Tree_itTree);
  388.     IO_WriteNl(Tree_f);
  389.     IO_WriteS(Tree_f, (STRING)"# define close", 14L);
  390.     Tree_WI(Tree_itTree);
  391.     IO_WriteS(Tree_f, (STRING)"(a)    yyChild = a; a = ", 21L);
  392.     Tree_WI(Tree_iNoTree);
  393.     IO_WriteS(Tree_f, (STRING)"; yyRelease", 11L);
  394.     Tree_WI(Tree_iModule);
  395.     IO_WriteS(Tree_f, (STRING)" (yyChild);", 11L);
  396.     IO_WriteNl(Tree_f);
  397.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  398.     IO_WriteNl(Tree_f);
  399.     IO_WriteS(Tree_f, (STRING)"# ifndef read", 13L);
  400.     Tree_WI(Tree_itTree);
  401.     IO_WriteNl(Tree_f);
  402.     IO_WriteS(Tree_f, (STRING)"# define read", 13L);
  403.     Tree_WI(Tree_itTree);
  404.     IO_WriteS(Tree_f, (STRING)"(a)    yyRead", 10L);
  405.     Tree_WI(Tree_iModule);
  406.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  407.     IO_WriteNl(Tree_f);
  408.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  409.     IO_WriteNl(Tree_f);
  410.     IO_WriteS(Tree_f, (STRING)"# ifndef write", 14L);
  411.     Tree_WI(Tree_itTree);
  412.     IO_WriteNl(Tree_f);
  413.     IO_WriteS(Tree_f, (STRING)"# define write", 14L);
  414.     Tree_WI(Tree_itTree);
  415.     IO_WriteS(Tree_f, (STRING)"(a)    yyWrite", 11L);
  416.     Tree_WI(Tree_iModule);
  417.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  418.     IO_WriteNl(Tree_f);
  419.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  420.     IO_WriteNl(Tree_f);
  421.     IO_WriteS(Tree_f, (STRING)"# ifndef get", 12L);
  422.     Tree_WI(Tree_itTree);
  423.     IO_WriteNl(Tree_f);
  424.     IO_WriteS(Tree_f, (STRING)"# define get", 12L);
  425.     Tree_WI(Tree_itTree);
  426.     IO_WriteS(Tree_f, (STRING)"(a)    yyGet", 9L);
  427.     Tree_WI(Tree_iModule);
  428.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  429.     IO_WriteNl(Tree_f);
  430.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  431.     IO_WriteNl(Tree_f);
  432.     IO_WriteS(Tree_f, (STRING)"# ifndef put", 12L);
  433.     Tree_WI(Tree_itTree);
  434.     IO_WriteNl(Tree_f);
  435.     IO_WriteS(Tree_f, (STRING)"# define put", 12L);
  436.     Tree_WI(Tree_itTree);
  437.     IO_WriteS(Tree_f, (STRING)"(a)    yyPut", 9L);
  438.     Tree_WI(Tree_iModule);
  439.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  440.     IO_WriteNl(Tree_f);
  441.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  442.     IO_WriteNl(Tree_f);
  443.     IO_WriteS(Tree_f, (STRING)"# ifndef copy", 13L);
  444.     Tree_WI(Tree_itTree);
  445.     IO_WriteNl(Tree_f);
  446.     IO_WriteS(Tree_f, (STRING)"# define copy", 13L);
  447.     Tree_WI(Tree_itTree);
  448.     IO_WriteS(Tree_f, (STRING)"(a, b)    yyCopy", 13L);
  449.     Tree_WI(Tree_iModule);
  450.     IO_WriteS(Tree_f, (STRING)" (b, & a);", 10L);
  451.     IO_WriteNl(Tree_f);
  452.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  453.     IO_WriteNl(Tree_f);
  454.     IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  455.     Tree_WI(Tree_itTree);
  456.     IO_WriteNl(Tree_f);
  457.     IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  458.     Tree_WI(Tree_itTree);
  459.     IO_WriteS(Tree_f, (STRING)"(a, b)    IsEqual", 14L);
  460.     Tree_WI(Tree_iModule);
  461.     IO_WriteS(Tree_f, (STRING)" (a, b)", 7L);
  462.     IO_WriteNl(Tree_f);
  463.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  464.     IO_WriteNl(Tree_f);
  465.   } else {
  466.     IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  467.     Tree_WI(Tree_itTree);
  468.     IO_WriteNl(Tree_f);
  469.     IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  470.     Tree_WI(Tree_itTree);
  471.     IO_WriteS(Tree_f, (STRING)"(a)    a := ", 9L);
  472.     Tree_WI(Tree_iNoTree);
  473.     IO_WriteS(Tree_f, (STRING)";", 1L);
  474.     IO_WriteNl(Tree_f);
  475.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  476.     IO_WriteNl(Tree_f);
  477.     IO_WriteS(Tree_f, (STRING)"# ifndef close", 14L);
  478.     Tree_WI(Tree_itTree);
  479.     IO_WriteNl(Tree_f);
  480.     IO_WriteS(Tree_f, (STRING)"# define close", 14L);
  481.     Tree_WI(Tree_itTree);
  482.     IO_WriteS(Tree_f, (STRING)"(a)    yyChild := a; a := ", 23L);
  483.     Tree_WI(Tree_iNoTree);
  484.     IO_WriteS(Tree_f, (STRING)"; yyRelease", 11L);
  485.     Tree_WI(Tree_iModule);
  486.     IO_WriteS(Tree_f, (STRING)" (yyChild);", 11L);
  487.     IO_WriteNl(Tree_f);
  488.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  489.     IO_WriteNl(Tree_f);
  490.     IO_WriteS(Tree_f, (STRING)"# ifndef read", 13L);
  491.     Tree_WI(Tree_itTree);
  492.     IO_WriteNl(Tree_f);
  493.     IO_WriteS(Tree_f, (STRING)"# define read", 13L);
  494.     Tree_WI(Tree_itTree);
  495.     IO_WriteS(Tree_f, (STRING)"(a)    yyRead", 10L);
  496.     Tree_WI(Tree_iModule);
  497.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  498.     IO_WriteNl(Tree_f);
  499.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  500.     IO_WriteNl(Tree_f);
  501.     IO_WriteS(Tree_f, (STRING)"# ifndef write", 14L);
  502.     Tree_WI(Tree_itTree);
  503.     IO_WriteNl(Tree_f);
  504.     IO_WriteS(Tree_f, (STRING)"# define write", 14L);
  505.     Tree_WI(Tree_itTree);
  506.     IO_WriteS(Tree_f, (STRING)"(a)    yyWrite", 11L);
  507.     Tree_WI(Tree_iModule);
  508.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  509.     IO_WriteNl(Tree_f);
  510.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  511.     IO_WriteNl(Tree_f);
  512.     IO_WriteS(Tree_f, (STRING)"# ifndef get", 12L);
  513.     Tree_WI(Tree_itTree);
  514.     IO_WriteNl(Tree_f);
  515.     IO_WriteS(Tree_f, (STRING)"# define get", 12L);
  516.     Tree_WI(Tree_itTree);
  517.     IO_WriteS(Tree_f, (STRING)"(a)    yyGet", 9L);
  518.     Tree_WI(Tree_iModule);
  519.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  520.     IO_WriteNl(Tree_f);
  521.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  522.     IO_WriteNl(Tree_f);
  523.     IO_WriteS(Tree_f, (STRING)"# ifndef put", 12L);
  524.     Tree_WI(Tree_itTree);
  525.     IO_WriteNl(Tree_f);
  526.     IO_WriteS(Tree_f, (STRING)"# define put", 12L);
  527.     Tree_WI(Tree_itTree);
  528.     IO_WriteS(Tree_f, (STRING)"(a)    yyPut", 9L);
  529.     Tree_WI(Tree_iModule);
  530.     IO_WriteS(Tree_f, (STRING)" (a);", 5L);
  531.     IO_WriteNl(Tree_f);
  532.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  533.     IO_WriteNl(Tree_f);
  534.     IO_WriteS(Tree_f, (STRING)"# ifndef copy", 13L);
  535.     Tree_WI(Tree_itTree);
  536.     IO_WriteNl(Tree_f);
  537.     IO_WriteS(Tree_f, (STRING)"# define copy", 13L);
  538.     Tree_WI(Tree_itTree);
  539.     IO_WriteS(Tree_f, (STRING)"(a, b)    yyCopy", 13L);
  540.     Tree_WI(Tree_iModule);
  541.     IO_WriteS(Tree_f, (STRING)" (b, SYSTEM.ADR (a));", 21L);
  542.     IO_WriteNl(Tree_f);
  543.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  544.     IO_WriteNl(Tree_f);
  545.     IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  546.     Tree_WI(Tree_itTree);
  547.     IO_WriteNl(Tree_f);
  548.     IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  549.     Tree_WI(Tree_itTree);
  550.     IO_WriteS(Tree_f, (STRING)"(a, b)    IsEqual", 14L);
  551.     Tree_WI(Tree_iModule);
  552.     IO_WriteS(Tree_f, (STRING)" (a, b)", 7L);
  553.     IO_WriteNl(Tree_f);
  554.     IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  555.     IO_WriteNl(Tree_f);
  556.   }
  557.   IO_WriteClose(Tree_f);
  558. }
  559.  
  560. static void ReadTraceTab
  561. # ifdef __STDC__
  562. ()
  563. # else
  564. ()
  565. # endif
  566. {
  567.   IO_tFile TraceTabFile;
  568.   Strings_tString s;
  569.   Tree_tTree t;
  570.  
  571.   TraceTabFile = IO_ReadOpen((STRING)"TraceTab", 8L);
  572.   if (TraceTabFile >= 0) {
  573.     while (!IO_EndOfFile(TraceTabFile)) {
  574.       Strings_ReadL(TraceTabFile, &s);
  575.       t = Tree_IdentifyClass(Tree_TreeRoot->U_1.V_26.Ag.Classes, Idents_MakeIdent(&s));
  576.       if (t != Tree_NoTree) {
  577.         SetTrace(t);
  578.         Tree_ForallClasses(t->U_1.V_5.Class.Extensions, (Tree_ProcOfT)SetTrace);
  579.       }
  580.     }
  581.     IO_ReadClose(TraceTabFile);
  582.   }
  583. }
  584.  
  585. static void SetTrace
  586. # ifdef __STDC__
  587. (Tree_tTree t)
  588. # else
  589. (t)
  590. Tree_tTree t;
  591. # endif
  592. {
  593.   INCL(t->U_1.V_5.Class.Properties, Tree_Trace);
  594. }
  595.  
  596. static IO_tFile SmartOpen
  597. # ifdef __STDC__
  598. (Strings_tString FileName)
  599. # else
  600. (FileName)
  601. Strings_tString FileName;
  602. # endif
  603. {
  604.   Strings_tString PathS;
  605.  
  606.   if (Sets_IsElement(ORD('7'), &Tree_Options)) {
  607.     Strings_ArrayToString((STRING)"yy", 2L, &PathS);
  608.     Strings_Concatenate(&PathS, &FileName);
  609.     Strings_Append(&PathS, '\0');
  610.     Strings_StringToArray(&PathS, PathA.A, 256L);
  611.   } else {
  612.     Strings_Append(&FileName, '\0');
  613.     Strings_StringToArray(&FileName, PathA.A, 256L);
  614.   }
  615.   return IO_WriteOpen(PathA.A, 256L);
  616. }
  617.  
  618. static void SmartClose
  619. # ifdef __STDC__
  620. (Strings_tString FileName, IO_tFile f)
  621. # else
  622. (FileName, f)
  623. Strings_tString FileName;
  624. IO_tFile f;
  625. # endif
  626. {
  627.   Strings_tString PathS;
  628.  
  629.   IO_WriteClose(f);
  630.   if (Sets_IsElement(ORD('7'), &Tree_Options)) {
  631.     Strings_ArrayToString((STRING)"gmdupd ", 7L, &PathS);
  632.     Strings_Concatenate(&PathS, &FileName);
  633.     Strings_ArrayToString((STRING)" yy", 3L, &String);
  634.     Strings_Concatenate(&PathS, &String);
  635.     Strings_Concatenate(&PathS, &FileName);
  636.     Strings_Append(&PathS, '\0');
  637.     Strings_StringToArray(&PathS, PathA.A, 256L);
  638.     j = System(PathA.A, 256L);
  639.   }
  640. }
  641.  
  642. void BEGIN_MODULE()
  643. {
  644.   BEGIN_System();
  645.   BEGIN_Memory();
  646.   BEGIN_IO();
  647.   BEGIN_Strings();
  648.   BEGIN_Idents();
  649.   BEGIN_Sets();
  650.   BEGIN_Errors();
  651.   BEGIN_Scanner();
  652.   BEGIN_Parser();
  653.   BEGIN_Tree();
  654.   BEGIN_Tree2();
  655.   BEGIN_Semantics();
  656.   BEGIN_Order();
  657.   BEGIN_Dialog();
  658.   BEGIN_GramMod();
  659.   BEGIN_TreeMod1();
  660.   BEGIN_EvalMod();
  661.   BEGIN_EvalMod2();
  662.   BEGIN_EvalMod3();
  663.   BEGIN_GramC();
  664.   BEGIN_GramYacc();
  665.   BEGIN_TreeC1();
  666.   BEGIN_EvalC();
  667.   BEGIN_EvalC2();
  668.   BEGIN_EvalC3();
  669.  
  670.   Strings_AssignEmpty(&CgLib);
  671.   Tree_SourceFile.A[0] = '\0';
  672.   Scanner_ArgCount = GetArgCount() - 1;
  673.   HasArgs = FALSE;
  674.   Scanner_CurArg = 0;
  675.   for (;;) {
  676.     INC(Scanner_CurArg);
  677.     if (Scanner_CurArg > Scanner_ArgCount) {
  678.       goto EXIT_1;
  679.     }
  680.     GetArgument(Scanner_CurArg, Argument.A, 256L);
  681.     if (Argument.A[0] == '-') {
  682.       if (Argument.A[1] == 'l') {
  683.         Strings_AssignEmpty(&CgLib);
  684.         j = 2;
  685.         for (;;) {
  686.           ch = Argument.A[j];
  687.           if (ch == '\0') {
  688.             goto EXIT_2;
  689.           }
  690.           Strings_Append(&CgLib, ch);
  691.           INC(j);
  692.         } EXIT_2:;
  693.         Strings_Append(&CgLib, '/');
  694.       } else {
  695.         j = 0;
  696.         for (;;) {
  697.           INC(j);
  698.           ch = Argument.A[j];
  699.           if (ch == '\0') {
  700.             goto EXIT_3;
  701.           } else if (ch == '?') {
  702.             Sets_Include(&Tree_Options, ORD('h'));
  703.             Sets_Include(&Tree_Options, ORD('H'));
  704.           } else {
  705.             Sets_Include(&Tree_Options, ORD(ch));
  706.           }
  707.         } EXIT_3:;
  708.         HasArgs = TRUE;
  709.       }
  710.     } else if (Argument.A[0] == '?') {
  711.       Sets_Include(&Tree_Options, ORD('h'));
  712.       Sets_Include(&Tree_Options, ORD('H'));
  713.       HasArgs = TRUE;
  714.     } else {
  715.       j = 0;
  716.       do {
  717.         ch = Argument.A[j];
  718.         Tree_SourceFile.A[j] = ch;
  719.         INC(j);
  720.       } while (!(ch == '\0'));
  721.       goto EXIT_1;
  722.     }
  723.   } EXIT_1:;
  724.   if (!HasArgs) {
  725.     Sets_Include(&Tree_Options, ORD('a'));
  726.     Sets_Include(&Tree_Options, ORD('A'));
  727.   }
  728.   if (Sets_IsElement(ORD('a'), &Tree_Options)) {
  729.     Sets_MakeSet(&AllOptions, 127L);
  730.     for (ch = 'a'; ch <= 'z'; ch += 1) {
  731.       Sets_Include(&AllOptions, ORD(ch));
  732.     }
  733.     Sets_Include(&AllOptions, ORD('F'));
  734.     Sets_Include(&AllOptions, ORD('R'));
  735.     Sets_Include(&AllOptions, ORD('='));
  736.     Sets_Exclude(&AllOptions, ORD('c'));
  737.     Sets_Exclude(&AllOptions, ORD('h'));
  738.     Sets_Exclude(&AllOptions, ORD('u'));
  739.     Sets_Exclude(&AllOptions, ORD('x'));
  740.     Sets_Exclude(&AllOptions, ORD('z'));
  741.     Sets_Union(&Tree_Options, AllOptions);
  742.     Sets_ReleaseSet(&AllOptions);
  743.   }
  744.   if (Sets_IsElement(ORD('k'), &Tree_Options) || Sets_IsElement(ORD('q'), &Tree_Options)) {
  745.     Sets_Include(&Tree_Options, ORD('o'));
  746.   }
  747.   if (Sets_IsElement(ORD('w'), &Tree_Options) || Sets_IsElement(ORD('p'), &Tree_Options) || Sets_IsElement(ORD('f'), &Tree_Options) || Sets_IsElement(ORD('k'), &Tree_Options) || Sets_IsElement(ORD('t'), &Tree_Options) || Sets_IsElement(ORD('b'), &Tree_Options) || Sets_IsElement(ORD('y'), &Tree_Options)) {
  748.     Sets_Include(&Tree_Options, ORD(','));
  749.   }
  750.   if (Sets_IsElement(ORD('w'), &Tree_Options) || Sets_IsElement(ORD('r'), &Tree_Options) || Sets_IsElement(ORD('p'), &Tree_Options) || Sets_IsElement(ORD('g'), &Tree_Options)) {
  751.     Sets_Include(&Tree_Options, ORD(';'));
  752.   }
  753.   if (Sets_IsElement(ORD('A'), &Tree_Options)) {
  754.     Sets_Include(&Tree_Options, ORD('D'));
  755.     Sets_Include(&Tree_Options, ORD('I'));
  756.   }
  757.   if (Sets_IsElement(ORD('T'), &Tree_Options) || Sets_IsElement(ORD('X'), &Tree_Options) || Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options)) {
  758.     Sets_Include(&Tree_Options, ORD('I'));
  759.   }
  760.   if (Sets_IsElement(ORD('I'), &Tree_Options) || Sets_IsElement(ORD('V'), &Tree_Options) || Sets_IsElement(ORD('M'), &Tree_Options) || Sets_IsElement(ORD('P'), &Tree_Options) || Sets_IsElement(ORD('S'), &Tree_Options) || Sets_IsElement(ORD('N'), &Tree_Options) || Sets_IsElement(ORD('O'), &Tree_Options) || Sets_IsElement(ORD('G'), &Tree_Options) || Sets_IsElement(ORD('E'), &Tree_Options) || Sets_IsElement(ORD('C'), &Tree_Options) || Sets_IsElement(ORD('J'), &Tree_Options) || Sets_IsElement(ORD('x'), &Tree_Options) || Sets_IsElement(ORD('z'), &Tree_Options) || Sets_IsElement(ORD('u'), &Tree_Options)) {
  761.     Sets_Include(&Tree_Options, ORD('.'));
  762.   }
  763.   if (Sets_IsElement(ORD('x'), &Tree_Options) || Sets_IsElement(ORD('z'), &Tree_Options) || Sets_IsElement(ORD('u'), &Tree_Options)) {
  764.     Sets_Include(&Tree_Options, ORD('B'));
  765.   }
  766.   if (Sets_IsElement(ORD('T'), &Tree_Options)) {
  767.     Sets_Include(&Tree_Options, ORD('X'));
  768.     Sets_Include(&Tree_Options, ORD('Z'));
  769.   }
  770.   if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  771.     Sets_Include(&Tree_Options, ORD('Y'));
  772.   }
  773.   if (Sets_IsElement(ORD('h'), &Tree_Options)) {
  774.     Sets_Exclude(&Tree_Options, ORD('h'));
  775.     Tree_f = IO_StdOutput;
  776.     IO_WriteNl(Tree_f);
  777.     IO_WriteS(Tree_f, (STRING)"usage: cg [-options] [-ldir] [files]", 36L);
  778.     IO_WriteNl(Tree_f);
  779.     IO_WriteNl(Tree_f);
  780.     IO_WriteS(Tree_f, (STRING)"options for tree/graph module", 29L);
  781.     IO_WriteNl(Tree_f);
  782.     IO_WriteNl(Tree_f);
  783.     IO_WriteS(Tree_f, (STRING)" a generate all except -ch (default)", 36L);
  784.     IO_WriteNl(Tree_f);
  785.     IO_WriteS(Tree_f, (STRING)" n generate node constructors    procedures n<node> (node)", 58L);
  786.     IO_WriteNl(Tree_f);
  787.     IO_WriteS(Tree_f, (STRING)" m generate node constructors    procedures m<node> (make)", 58L);
  788.     IO_WriteNl(Tree_f);
  789.     IO_WriteS(Tree_f, (STRING)" f generate node/graph destroyer procedure ReleaseTREE (free)", 61L);
  790.     IO_WriteNl(Tree_f);
  791.     IO_WriteS(Tree_f, (STRING)" F generate general    destroyer procedure ReleaseTREEModule (FREE)", 67L);
  792.     IO_WriteNl(Tree_f);
  793.     IO_WriteS(Tree_f, (STRING)" o generate ascii  node  writer  procedure WriteTREENode (output)", 65L);
  794.     IO_WriteNl(Tree_f);
  795.     IO_WriteS(Tree_f, (STRING)" r generate ascii  graph reader  procedure ReadTREE", 51L);
  796.     IO_WriteNl(Tree_f);
  797.     IO_WriteS(Tree_f, (STRING)" w generate ascii  graph writer  procedure WriteTREE", 52L);
  798.     IO_WriteNl(Tree_f);
  799.     IO_WriteS(Tree_f, (STRING)" g generate binary graph reader  procedure GetTREE", 50L);
  800.     IO_WriteNl(Tree_f);
  801.     IO_WriteS(Tree_f, (STRING)" p generate binary graph writer  procedure PutTREE", 50L);
  802.     IO_WriteNl(Tree_f);
  803.     IO_WriteS(Tree_f, (STRING)" R generate list reverser        procedure ReverseTREE", 54L);
  804.     IO_WriteNl(Tree_f);
  805.     IO_WriteS(Tree_f, (STRING)" t generate top down  traversal  procedure TraverseTREETD", 57L);
  806.     IO_WriteNl(Tree_f);
  807.     IO_WriteS(Tree_f, (STRING)" b generate bottom up traversal  procedure TraverseTREEBU", 57L);
  808.     IO_WriteNl(Tree_f);
  809.     IO_WriteS(Tree_f, (STRING)" y generate graph copy           procedure CopyTREE", 51L);
  810.     IO_WriteNl(Tree_f);
  811.     IO_WriteS(Tree_f, (STRING)" k generate graph checker        procedure CheckTREE", 52L);
  812.     IO_WriteNl(Tree_f);
  813.     IO_WriteS(Tree_f, (STRING)" q generate graph browser        procedure QueryTREE", 52L);
  814.     IO_WriteNl(Tree_f);
  815.     IO_WriteS(Tree_f, (STRING)" = generate tree equality test   procedure IsEqualTREE", 54L);
  816.     IO_WriteNl(Tree_f);
  817.     IO_WriteS(Tree_f, (STRING)" d generate definition     module", 33L);
  818.     IO_WriteNl(Tree_f);
  819.     IO_WriteS(Tree_f, (STRING)" i generate implementation module", 33L);
  820.     IO_WriteNl(Tree_f);
  821.     IO_WriteS(Tree_f, (STRING)" s generate import statements", 29L);
  822.     IO_WriteNl(Tree_f);
  823.     IO_WriteS(Tree_f, (STRING)" 4 generate tree/graph description in file TREE.TS", 50L);
  824.     IO_WriteNl(Tree_f);
  825.     IO_WriteS(Tree_f, (STRING)" 6 generate # line directives", 29L);
  826.     IO_WriteNl(Tree_f);
  827.     IO_WriteS(Tree_f, (STRING)" 7 touch output files only if necessary", 39L);
  828.     IO_WriteNl(Tree_f);
  829.     IO_WriteS(Tree_f, (STRING)" 8 report storage consumption", 29L);
  830.     IO_WriteNl(Tree_f);
  831.     IO_WriteS(Tree_f, (STRING)" c generate C code (default is Modula-2)", 40L);
  832.     IO_WriteNl(Tree_f);
  833.     IO_WriteS(Tree_f, (STRING)" h print help information for tree/graph module", 47L);
  834.     IO_WriteNl(Tree_f);
  835.     IO_WriteS(Tree_f, (STRING)" H print help information for evaluator  module", 47L);
  836.     IO_WriteNl(Tree_f);
  837.     IO_WriteS(Tree_f, (STRING)" -ldir specify the directory dir where cg finds its tables", 58L);
  838.     IO_WriteNl(Tree_f);
  839.     IO_WriteNl(Tree_f);
  840.     IO_WriteS(Tree_f, (STRING)"options for scanner and parser interface", 40L);
  841.     IO_WriteNl(Tree_f);
  842.     IO_WriteNl(Tree_f);
  843.     IO_WriteS(Tree_f, (STRING)" x generate scanner specification", 33L);
  844.     IO_WriteNl(Tree_f);
  845.     IO_WriteS(Tree_f, (STRING)" z generate parser  specification for lalr", 42L);
  846.     IO_WriteNl(Tree_f);
  847.     IO_WriteS(Tree_f, (STRING)" u generate parser  specification for yacc", 42L);
  848.     IO_WriteNl(Tree_f);
  849.     IO_WriteS(Tree_f, (STRING)" v omit actions in the generated parser specifications", 54L);
  850.     IO_WriteNl(Tree_f);
  851.     IO_WriteS(Tree_f, (STRING)" j allow undefined node types; define implicitly as terminals", 61L);
  852.     IO_WriteNl(Tree_f);
  853.   }
  854.   if (Sets_IsElement(ORD('H'), &Tree_Options)) {
  855.     Sets_Exclude(&Tree_Options, ORD('H'));
  856.     Tree_f = IO_StdOutput;
  857.     IO_WriteNl(Tree_f);
  858.     IO_WriteS(Tree_f, (STRING)"usage: cg [-options] [-ldir] [files]", 36L);
  859.     IO_WriteNl(Tree_f);
  860.     IO_WriteNl(Tree_f);
  861.     IO_WriteS(Tree_f, (STRING)"options for evaluator module", 28L);
  862.     IO_WriteNl(Tree_f);
  863.     IO_WriteNl(Tree_f);
  864.     IO_WriteS(Tree_f, (STRING)" A generate all, same as -DI (default)", 38L);
  865.     IO_WriteNl(Tree_f);
  866.     IO_WriteS(Tree_f, (STRING)" D generate definition     module", 33L);
  867.     IO_WriteNl(Tree_f);
  868.     IO_WriteS(Tree_f, (STRING)" I generate implementation module", 33L);
  869.     IO_WriteNl(Tree_f);
  870.     IO_WriteS(Tree_f, (STRING)" L generate a (lazy) evaluator for WAG (default OAG)", 52L);
  871.     IO_WriteNl(Tree_f);
  872.     IO_WriteS(Tree_f, (STRING)" W suppress warnings", 20L);
  873.     IO_WriteNl(Tree_f);
  874.     IO_WriteS(Tree_f, (STRING)" B allow missing attribute computations in extended node types", 62L);
  875.     IO_WriteNl(Tree_f);
  876.     IO_WriteS(Tree_f, (STRING)" V print visit sequences", 24L);
  877.     IO_WriteNl(Tree_f);
  878.     IO_WriteS(Tree_f, (STRING)" M print summary of all node types (rules) from source", 54L);
  879.     IO_WriteNl(Tree_f);
  880.     IO_WriteS(Tree_f, (STRING)" P print dependency relations DP", 32L);
  881.     IO_WriteNl(Tree_f);
  882.     IO_WriteS(Tree_f, (STRING)" S print dependency relations SNC", 33L);
  883.     IO_WriteNl(Tree_f);
  884.     IO_WriteS(Tree_f, (STRING)" N print dependency relations DNC", 33L);
  885.     IO_WriteNl(Tree_f);
  886.     IO_WriteS(Tree_f, (STRING)" O print dependency relations OAG", 33L);
  887.     IO_WriteNl(Tree_f);
  888.     IO_WriteS(Tree_f, (STRING)" G print attribute instances sorted by declaration order", 56L);
  889.     IO_WriteNl(Tree_f);
  890.     IO_WriteS(Tree_f, (STRING)" E print attribute instances sorted by evaluation order", 55L);
  891.     IO_WriteNl(Tree_f);
  892.     IO_WriteS(Tree_f, (STRING)" C print dependencies introduced for total order", 48L);
  893.     IO_WriteNl(Tree_f);
  894.     IO_WriteS(Tree_f, (STRING)" T generate evaluator with trace output (all actions, T = XZ)", 61L);
  895.     IO_WriteNl(Tree_f);
  896.     IO_WriteS(Tree_f, (STRING)" U trace only node types specified in file TraceTab", 51L);
  897.     IO_WriteNl(Tree_f);
  898.     IO_WriteS(Tree_f, (STRING)" X trace attribute evaluation actions with    values", 52L);
  899.     IO_WriteNl(Tree_f);
  900.     IO_WriteS(Tree_f, (STRING)" Y trace attribute evaluation actions without values", 52L);
  901.     IO_WriteNl(Tree_f);
  902.     IO_WriteS(Tree_f, (STRING)" Z trace visit actions", 22L);
  903.     IO_WriteNl(Tree_f);
  904.     IO_WriteS(Tree_f, (STRING)" J start dialog system", 22L);
  905.     IO_WriteNl(Tree_f);
  906.     IO_WriteS(Tree_f, (STRING)" Q browse internal data structure", 33L);
  907.     IO_WriteNl(Tree_f);
  908.     IO_WriteS(Tree_f, (STRING)" 0 optimize attribute storage", 29L);
  909.     IO_WriteNl(Tree_f);
  910.     IO_WriteS(Tree_f, (STRING)" 1 print inserted copy rules", 28L);
  911.     IO_WriteNl(Tree_f);
  912.     IO_WriteS(Tree_f, (STRING)" 2 print inherited attribute computation rules", 46L);
  913.     IO_WriteNl(Tree_f);
  914.     IO_WriteS(Tree_f, (STRING)" 3 print attribute storage assignment", 37L);
  915.     IO_WriteNl(Tree_f);
  916.     IO_WriteS(Tree_f, (STRING)" 5 generate code to check for cyclic dependencies", 49L);
  917.     IO_WriteNl(Tree_f);
  918.     IO_WriteS(Tree_f, (STRING)" 6 generate # line directives", 29L);
  919.     IO_WriteNl(Tree_f);
  920.     IO_WriteS(Tree_f, (STRING)" 7 touch output files only if necessary", 39L);
  921.     IO_WriteNl(Tree_f);
  922.     IO_WriteS(Tree_f, (STRING)" 8 report storage consumption", 29L);
  923.     IO_WriteNl(Tree_f);
  924.     IO_WriteS(Tree_f, (STRING)" 9 generate code to measure stack size", 38L);
  925.     IO_WriteNl(Tree_f);
  926.     IO_WriteS(Tree_f, (STRING)" c generate C code (default is Modula-2)", 40L);
  927.     IO_WriteNl(Tree_f);
  928.     IO_WriteS(Tree_f, (STRING)" H print help information for evaluator  module", 47L);
  929.     IO_WriteNl(Tree_f);
  930.     IO_WriteS(Tree_f, (STRING)" h print help information for tree/graph module", 47L);
  931.     IO_WriteNl(Tree_f);
  932.     IO_WriteS(Tree_f, (STRING)" -ldir specify the directory dir where cg finds its tables", 58L);
  933.     IO_WriteNl(Tree_f);
  934.     IO_WriteNl(Tree_f);
  935.     IO_WriteS(Tree_f, (STRING)"implications", 12L);
  936.     IO_WriteNl(Tree_f);
  937.     IO_WriteNl(Tree_f);
  938.     IO_WriteS(Tree_f, (STRING)" {}              -> {a, A}", 26L);
  939.     IO_WriteNl(Tree_f);
  940.     IO_WriteS(Tree_f, (STRING)" a               -> {a-z, F, R} - {c, e, h, u, x, z}", 52L);
  941.     IO_WriteNl(Tree_f);
  942.     IO_WriteS(Tree_f, (STRING)" A               -> {D, I}", 26L);
  943.     IO_WriteNl(Tree_f);
  944.     IO_WriteS(Tree_f, (STRING)" {L, T, X, Y, Z} -> I", 21L);
  945.     IO_WriteNl(Tree_f);
  946.     IO_WriteS(Tree_f, (STRING)" T               -> {X, Z}", 26L);
  947.     IO_WriteNl(Tree_f);
  948.   }
  949.   if (!Sets_IsEmpty(Tree_Options)) {
  950.     Strings_ArrayToString(Scanner_ScanTabName.A, 128L, &String);
  951.     Strings_Assign(&PathS, &CgLib);
  952.     Strings_Concatenate(&PathS, &String);
  953.     Strings_Append(&PathS, '\0');
  954.     Strings_StringToArray(&PathS, Scanner_ScanTabName.A, 128L);
  955.     Strings_ArrayToString(Parser_ParsTabName.A, 129L, &String);
  956.     Strings_Assign(&PathS, &CgLib);
  957.     Strings_Concatenate(&PathS, &String);
  958.     Strings_Append(&PathS, '\0');
  959.     Strings_StringToArray(&PathS, Parser_ParsTabName.A, 129L);
  960.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  961.       Strings_ArrayToString((STRING)"int", 3L, &String);
  962.     } else {
  963.       Strings_ArrayToString((STRING)"INTEGER", 7L, &String);
  964.     }
  965.     Tree_iInteger = Idents_MakeIdent(&String);
  966.     if (Tree_SourceFile.A[0] != '\0') {
  967.       Scanner_BeginFile(Tree_SourceFile.A, 256L);
  968.       Strings_ArrayToString(Tree_SourceFile.A, 256L, &String);
  969.       Scanner_Attribute.Position.File = Idents_MakeIdent(&String);
  970.     }
  971.     Errors_StoreMessages(TRUE);
  972.     Tree_ErrorCount = Parser_Parser();
  973.     Tree_BeginTree2();
  974.     Semantics_Semantics(Tree_TreeRoot);
  975.     if (Tree_ErrorCount > 0) {
  976.       Errors_WriteMessages((System_tFile)IO_StdError);
  977.       IO_CloseIO();
  978.       Exit(1L);
  979.     }
  980.   }
  981.   if (Sets_IsElement(ORD('x'), &Tree_Options)) {
  982.     if (Tree_TreeRoot->U_1.V_26.Ag.ScannerName == Idents_NoIdent) {
  983.       Strings_ArrayToString((STRING)"Scanner", 7L, &PathS);
  984.     } else {
  985.       Idents_GetString(Tree_TreeRoot->U_1.V_26.Ag.ScannerName, &PathS);
  986.     }
  987.     Strings_ArrayToString((STRING)".rpp", 4L, &String);
  988.     Strings_Concatenate(&PathS, &String);
  989.     Tree_f = SmartOpen(PathS);
  990.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  991.       GramC_ScanSpec(Tree_TreeRoot);
  992.     } else {
  993.       GramMod_ScanSpec(Tree_TreeRoot);
  994.     }
  995.     SmartClose(PathS, Tree_f);
  996.   }
  997.   if (Sets_IsElement(ORD('z'), &Tree_Options)) {
  998.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Ag.ParserName, &Tree_ModuleName);
  999.     Strings_Assign(&PathS, &Tree_ModuleName);
  1000.     Strings_ArrayToString((STRING)".lalr", 5L, &String);
  1001.     Strings_Concatenate(&PathS, &String);
  1002.     Tree_f = SmartOpen(PathS);
  1003.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1004.       GramC_ParsSpec(Tree_TreeRoot);
  1005.     } else {
  1006.       GramMod_ParsSpec(Tree_TreeRoot);
  1007.     }
  1008.     SmartClose(PathS, Tree_f);
  1009.   } else if (Sets_IsElement(ORD('u'), &Tree_Options)) {
  1010.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Ag.ParserName, &Tree_ModuleName);
  1011.     Strings_Assign(&PathS, &Tree_ModuleName);
  1012.     Strings_ArrayToString((STRING)".y", 2L, &String);
  1013.     Strings_Concatenate(&PathS, &String);
  1014.     Tree_f = SmartOpen(PathS);
  1015.     GramYacc_ParsSpec(Tree_TreeRoot);
  1016.     SmartClose(PathS, Tree_f);
  1017.   }
  1018.   if (Sets_IsElement(ORD('.'), &Tree_Options)) {
  1019.     Order_Order(Tree_TreeRoot);
  1020.   }
  1021.   Errors_WriteMessages((System_tFile)IO_StdError);
  1022.   Errors_StoreMessages(TRUE);
  1023.   if (Sets_IsElement(ORD('Q'), &Tree_Options)) {
  1024.     Tree_QueryTree(Tree_TreeRoot);
  1025.   }
  1026.   if (Sets_IsElement(ORD('J'), &Tree_Options)) {
  1027.     Dialog_Dialog(Tree_TreeRoot);
  1028.   }
  1029.   if (Tree_ErrorCount > 0) {
  1030.     IO_CloseIO();
  1031.     Exit(1L);
  1032.   }
  1033.   if (Sets_IsElement(ORD('i'), &Tree_Options) || Sets_IsElement(ORD('X'), &Tree_Options)) {
  1034.     GenerateMacros();
  1035.   }
  1036.   if (Sets_IsElement(ORD('d'), &Tree_Options)) {
  1037.     Idents_GetString(Tree_iModule, &Tree_ModuleName);
  1038.     Strings_Assign(&PathS, &Tree_ModuleName);
  1039.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1040.       Strings_ArrayToString(DefExtC, 2L, &String);
  1041.     } else {
  1042.       Strings_ArrayToString(DefExtMc, 3L, &String);
  1043.     }
  1044.     Strings_Concatenate(&PathS, &String);
  1045.     Strings_Assign(&DefFile, &PathS);
  1046.     Tree_f = SmartOpen(PathS);
  1047.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1048.       TreeC1_TreeDefC(Tree_TreeRoot);
  1049.     } else {
  1050.       TreeMod1_TreeDefMod(Tree_TreeRoot);
  1051.     }
  1052.     SmartClose(PathS, Tree_f);
  1053.     if (!Sets_IsElement(ORD('c'), &Tree_Options)) {
  1054.       Strings_ArrayToString((STRING)"gmdcpp ", 7L, &PathS);
  1055.       Strings_Concatenate(&PathS, &DefFile);
  1056.       Strings_Append(&PathS, '\0');
  1057.       Strings_StringToArray(&PathS, PathA.A, 256L);
  1058.       j = System(PathA.A, 256L);
  1059.     }
  1060.   }
  1061.   if (Sets_IsElement(ORD('4'), &Tree_Options)) {
  1062.     Idents_GetString(Tree_ViewName, &PathS);
  1063.     Strings_ArrayToString((STRING)".TS", 3L, &String);
  1064.     Strings_Concatenate(&PathS, &String);
  1065.     Tree_f = SmartOpen(PathS);
  1066.     Idents_WriteIdent(Tree_f, Tree_iModule);
  1067.     IO_WriteNl(Tree_f);
  1068.     Tree2_PutTree2(Tree_f, Tree_TreeRoot->U_1.V_26.Ag.Classes);
  1069.     SmartClose(PathS, Tree_f);
  1070.   }
  1071.   if (Sets_IsElement(ORD('i'), &Tree_Options)) {
  1072.     Idents_GetString(Tree_iModule, &Tree_ModuleName);
  1073.     Strings_Assign(&PathS, &Tree_ModuleName);
  1074.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1075.       Strings_ArrayToString(ImpExtC, 2L, &String);
  1076.     } else {
  1077.       Strings_ArrayToString(ImpExtMc, 3L, &String);
  1078.     }
  1079.     Strings_Concatenate(&PathS, &String);
  1080.     Strings_Assign(&TreeFile, &PathS);
  1081.     Tree_f = SmartOpen(PathS);
  1082.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1083.       TreeC1_TreeImplC(Tree_TreeRoot);
  1084.     } else {
  1085.       TreeMod1_TreeImplMod(Tree_TreeRoot);
  1086.     }
  1087.     SmartClose(PathS, Tree_f);
  1088.     if (!Sets_IsElement(ORD('c'), &Tree_Options)) {
  1089.       Strings_ArrayToString((STRING)"gmdcpp ", 7L, &PathS);
  1090.       Strings_Concatenate(&PathS, &TreeFile);
  1091.       Strings_Append(&PathS, '\0');
  1092.       Strings_StringToArray(&PathS, PathA.A, 256L);
  1093.       j = System(PathA.A, 256L);
  1094.     }
  1095.   }
  1096.   if (Sets_IsElement(ORD('s'), &Tree_Options) && !Sets_IsElement(ORD('c'), &Tree_Options)) {
  1097.     Idents_GetString(Tree_iModule, &Tree_ModuleName);
  1098.     Strings_Assign(&PathS, &Tree_ModuleName);
  1099.     Strings_ArrayToString(LisExtMc, 4L, &String);
  1100.     Strings_Concatenate(&PathS, &String);
  1101.     Tree_f = SmartOpen(PathS);
  1102.     TreeMod1_ImportList(Tree_TreeRoot);
  1103.     SmartClose(PathS, Tree_f);
  1104.   }
  1105.   if (Sets_IsElement(ORD('U'), &Tree_Options)) {
  1106.     ReadTraceTab();
  1107.   } else if (!Sets_IsEmpty(Tree_Options)) {
  1108.     Tree_ForallClasses(Tree_TreeRoot->U_1.V_26.Ag.Classes, (Tree_ProcOfT)SetTrace);
  1109.   }
  1110.   if (Sets_IsElement(ORD('D'), &Tree_Options)) {
  1111.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Ag.EvalName, &Tree_ModuleName);
  1112.     Strings_Assign(&PathS, &Tree_ModuleName);
  1113.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1114.       Strings_ArrayToString(DefExtC, 2L, &String);
  1115.     } else {
  1116.       Strings_ArrayToString(DefExtMc, 3L, &String);
  1117.     }
  1118.     Strings_Concatenate(&PathS, &String);
  1119.     Tree_f = SmartOpen(PathS);
  1120.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1121.       EvalC_EvalDefC(Tree_TreeRoot);
  1122.     } else {
  1123.       EvalMod_EvalDefMod(Tree_TreeRoot);
  1124.     }
  1125.     SmartClose(PathS, Tree_f);
  1126.   }
  1127.   if (Sets_IsElement(ORD('I'), &Tree_Options)) {
  1128.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Ag.EvalName, &Tree_ModuleName);
  1129.     Strings_Assign(&PathS, &Tree_ModuleName);
  1130.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1131.       Strings_ArrayToString(ImpExtC, 2L, &String);
  1132.     } else {
  1133.       Strings_ArrayToString(ImpExtMc, 3L, &String);
  1134.     }
  1135.     Strings_Concatenate(&PathS, &String);
  1136.     Strings_Assign(&EvalFile, &PathS);
  1137.     Tree_f = SmartOpen(PathS);
  1138.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  1139.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  1140.         EvalC3_EvalImplC(Tree_TreeRoot);
  1141.       } else if (Sets_IsElement(ORD('0'), &Tree_Options)) {
  1142.         EvalC2_EvalImplC(Tree_TreeRoot);
  1143.       } else {
  1144.         EvalC_EvalImplC(Tree_TreeRoot);
  1145.       }
  1146.     } else {
  1147.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  1148.         EvalMod3_EvalImplMod(Tree_TreeRoot);
  1149.       } else if (Sets_IsElement(ORD('0'), &Tree_Options)) {
  1150.         EvalMod2_EvalImplMod(Tree_TreeRoot);
  1151.       } else {
  1152.         EvalMod_EvalImplMod(Tree_TreeRoot);
  1153.       }
  1154.     }
  1155.     SmartClose(PathS, Tree_f);
  1156.     if (!Sets_IsElement(ORD('c'), &Tree_Options)) {
  1157.       Strings_ArrayToString((STRING)"gmdcpp ", 7L, &PathS);
  1158.       Strings_Concatenate(&PathS, &EvalFile);
  1159.       Strings_Append(&PathS, '\0');
  1160.       Strings_StringToArray(&PathS, PathA.A, 256L);
  1161.       j = System(PathA.A, 256L);
  1162.     }
  1163.   }
  1164.   if (!Sets_IsElement(ORD('c'), &Tree_Options)) {
  1165.     if (Sets_IsElement(ORD('i'), &Tree_Options) || Sets_IsElement(ORD('X'), &Tree_Options)) {
  1166.       Strings_ArrayToString((STRING)"gmdrm yy", 8L, &PathS);
  1167.       Idents_GetString(Tree_iModule, &Tree_ModuleName);
  1168.       Strings_Concatenate(&PathS, &Tree_ModuleName);
  1169.       Strings_ArrayToString((STRING)".w", 2L, &String);
  1170.       Strings_Concatenate(&PathS, &String);
  1171.       Strings_Append(&PathS, '\0');
  1172.       Strings_StringToArray(&PathS, PathA.A, 256L);
  1173.       j = System(PathA.A, 256L);
  1174.     }
  1175.   }
  1176.   if (Sets_IsElement(ORD('8'), &Tree_Options)) {
  1177.     IO_WriteNl((System_tFile)IO_StdError);
  1178.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Memory", 6L);
  1179.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Memory_MemoryUsed, 8L);
  1180.     IO_WriteS((System_tFile)IO_StdError, (STRING)"  Heap", 6L);
  1181.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Tree_HeapUsed, 8L);
  1182.     IO_WriteNl((System_tFile)IO_StdError);
  1183.   }
  1184.   Errors_WriteMessages((System_tFile)IO_StdError);
  1185.   IO_CloseIO();
  1186.   Exit(0L);
  1187. }
  1188.